// 使用统一配置入口模式
const pathResolver = require('../config/path_resolver.js');

// 从辅助工具配置导入
const { 
	dayjs, 
	dataHelper, 
	timeHelper, 
	cloudHelper, 
	pageHelper, 
	fileUtil, 
	fileHelper 
} = require('../config/project_helpers_config');

/**
 * PLM项目文件服务模块
 */
// 从服务配置导入
const { BaseService } = require('../config/services_config');
// 使用统一配置入口导入util模块
const { util } = require('../config/libs_config');

// 缓存KEY
const CACHE_FILE_LIST = 'CACHE_PLM_FILE_LIST';
const CACHE_FILE_DETAIL = 'CACHE_PLM_FILE_DETAIL';

// 兼容处理引入FileBiz
let FileBiz = null;
try {
	FileBiz = require('../config/biz_config').FileBiz;
} catch (e) {
	console.error('加载FileBiz失败:', e);
	// 提供备用实现
	FileBiz = {
		getFileExt: function(fileName) {
			if (!fileName) return '';
			
			const lastDot = fileName.lastIndexOf('.');
			if (lastDot === -1) return '';
			
			return fileName.substring(lastDot + 1).toLowerCase();
		},
		formatFileSize: function(size) {
			if (!size) return '0 B';
			
			const units = ['B', 'KB', 'MB', 'GB', 'TB'];
			let index = 0;
			let fileSize = size;
			
			while (fileSize >= 1024 && index < units.length - 1) {
				fileSize /= 1024;
				index++;
			}
			
			return fileSize.toFixed(2) + ' ' + units[index];
		},
		getFileIcon: function(fileName) {
			return '/images/file_doc.png';
		}
	};
}

class FileService extends BaseService {

	/**
	 * 构造函数
	 */
	constructor() {
		super();
		this._db = wx.cloud.database();
		this._collection = this._db.collection('plm_file');
	}

	/**
	 * 获取文件列表
	 * @param {Object} param 查询参数
	 * @param {String} param.projectId 项目ID 
	 * @param {String} param.search 搜索关键词
	 * @param {Number} param.page 页码
	 * @param {Number} param.size 每页数量
	 * @param {String} param.sortType 排序类型
	 * @param {String} param.sortVal 排序值
	 * @param {String} param.type 文件类型
	 * @param {String} param.tag 文件标签
	 */
	async getFileList(param) {
		try {
			// 构造查询参数
			let params = {
				projectId: param.projectId || '',
				search: param.search || '',
				sortType: param.sortType || '',
				sortVal: param.sortVal || '',
				type: param.type || '',
				tag: param.tag || '',
				page: param.page || 1,
				size: param.size || 20
			};
			
			// 调用云函数获取数据
			let options = {
				cacheKey: CACHE_FILE_LIST,
				...param.options
			};
			
			let result = await cloudHelper.callCloudData('plm_file/list', params, options);
			
			// 格式化文件大小
			if (result && result.list) {
				result.list = result.list.map(item => {
					if (item.size) {
						item.sizeDesc = fileUtil.getFormatSize(item.size);
					}
					return item;
				});
			}
			
			return result || { list: [], total: 0 };
		} catch (err) {
			console.error('获取文件列表失败', err);
			return { list: [], total: 0 };
		}
	}

	/**
	 * 获取文件详情
	 * @param {String} id 文件ID
	 */
	async getFileDetail(id) {
		if (!id) return null;
		
		try {
			let options = {
				cacheKey: CACHE_FILE_DETAIL + id
			};
			
			const result = await cloudHelper.callCloudData('plm_file/detail', { id }, options);
			
			if (result && result.size) {
				result.sizeDesc = fileUtil.getFormatSize(result.size);
			}
			
			return result;
		} catch (err) {
			console.error('获取文件详情失败', err);
			return null;
		}
	}

	/**
	 * 上传文件
	 * @param {Object} data 文件数据
	 * @param {String} data.projectId 项目ID
	 * @param {String} data.name 文件名
	 * @param {String} data.type 文件类型
	 * @param {String} data.tag 文件标签
	 * @param {String} data.desc 文件描述
	 * @param {String} data.fileID 云存储文件ID
	 * @param {Number} data.size 文件大小
	 */
	async uploadFile(data) {
		try {
			// 检查数据
			if (!data.projectId) throw new Error('项目ID不能为空');
			if (!data.name) throw new Error('文件名不能为空');
			if (!data.fileID) throw new Error('文件ID不能为空');
			
			// 准备提交数据
			const submitData = {
				projectId: data.projectId,
				name: data.name,
				type: data.type || FileBiz.getFileExt(data.name),
				tag: data.tag || '',
				desc: data.desc || '',
				fileID: data.fileID,
				size: data.size || 0,
				
				// 创建者信息
				createTime: dayjs(),
				updateTime: dayjs(),
				createBy: this._userId,
				createName: this._userName,
				
				// 状态信息
				status: 1, // 1-有效 0-无效
				version: 1, // 版本号
				sort: 9999, // 排序号
				
				// 统计信息
				viewCount: 0, // 查看次数
				downloadCount: 0 // 下载次数
			};
			
			// 调用云函数添加文件
			return await cloudHelper.callCloudData('plm_file/insert', submitData);
		} catch (err) {
			console.error('上传文件失败', err);
			throw err;
		}
	}

	/**
	 * 删除文件
	 * @param {String} id 文件ID
	 */
	async deleteFile(id) {
		if (!id) throw new Error('文件ID不能为空');
		
		try {
			return await cloudHelper.callCloudData('plm_file/delete', { id });
		} catch (err) {
			console.error('删除文件失败', err);
			throw err;
		}
	}

	/**
	 * 更新文件信息
	 * @param {Object} data 文件数据
	 */
	async updateFile(data) {
		try {
			// 检查ID
			const id = data.id || data._id;
			if (!id) throw new Error('文件ID不能为空');
			
			// 准备更新数据
			const updateData = {
				id,
				name: data.name,
				type: data.type,
				tag: data.tag,
				desc: data.desc,
				updateTime: dayjs(),
				sort: data.sort
			};
			
			// 调用云函数更新文件
			return await cloudHelper.callCloudData('plm_file/edit', updateData);
		} catch (err) {
			console.error('更新文件失败', err);
			throw err;
		}
	}

	/**
	 * 打开预览文件
	 * @param {Object} file 文件对象
	 */
	async openFile(file) {
		try {
			if (!file) throw new Error('文件不能为空');
			
			// 增加查看次数
			this.addViewCount(file.id || file._id);
			
			// 构造文件节点对象
			const fileNode = {
				name: file.name,
				path: file.fileID,
				type: fileUtil.isImageFile(file.name) ? 'image' : 'doc'
			};
			
			// 打开文件
			await fileHelper.openFile(fileNode);
			
			return true;
		} catch (err) {
			console.error('打开文件失败', err);
			pageHelper.showModal('打开文件失败: ' + err.message);
			return false;
		}
	}

	/**
	 * 增加文件查看次数
	 * @param {String} id 文件ID
	 */
	async addViewCount(id) {
		if (!id) return;
		
		try {
			await cloudHelper.callCloudData('plm_file/view', { id });
		} catch (err) {
			console.error('增加查看次数失败', err);
		}
	}

	/**
	 * 增加文件下载次数
	 * @param {String} id 文件ID
	 */
	async addDownloadCount(id) {
		if (!id) return;
		
		try {
			await cloudHelper.callCloudData('plm_file/download', { id });
		} catch (err) {
			console.error('增加下载次数失败', err);
		}
	}

	/**
	 * 获取文件链接
	 * @param {String} fileID 云存储文件ID
	 */
	async getFileUrl(fileID) {
		try {
			if (!fileID) return '';
			
			const result = await cloudHelper.getTempFileURLOne(fileID);
			return result || '';
		} catch (err) {
			console.error('获取文件链接失败', err);
			return '';
		}
	}

	/**
	 * 导出为静态类方法，方便直接调用
	 */
	static async getFileList(params, options = {}) {
		const service = new FileService();
		return await service.getFileList({...params, options});
	}
	
	static async getFileDetail(id, options = {}) {
		const service = new FileService();
		return await service.getFileDetail(id, options);
	}
	
	static async uploadFile(data) {
		const service = new FileService();
		return await service.uploadFile(data);
	}
	
	static async deleteFile(id) {
		const service = new FileService();
		return await service.deleteFile(id);
	}
	
	static async updateFile(data) {
		const service = new FileService();
		return await service.updateFile(data);
	}
	
	static async openFile(file) {
		const service = new FileService();
		return await service.openFile(file);
	}
	
	static async getFileUrl(fileID) {
		const service = new FileService();
		return await service.getFileUrl(fileID);
	}
}

module.exports = FileService; 